// 本地存储工具类

import type { FilterState, EnvironmentType } from '@/types';

const STORAGE_KEYS = {
  FILTER_STATE: 'env_manager_filter_state',
  ACTIVE_ENVIRONMENTS: 'env_manager_active_environments',
  ACTIVE_ENVIRONMENT_TYPE: 'env_manager_active_environment_type', // 新增：记录当前激活的环境类型
};

export class StorageManager {
  private static instance: StorageManager;

  private constructor() {}

  public static getInstance(): StorageManager {
    if (!StorageManager.instance) {
      StorageManager.instance = new StorageManager();
    }
    return StorageManager.instance;
  }

  // 保存筛选状态
  public saveFilterState(filterState: FilterState): void {
    try {
      localStorage.setItem(STORAGE_KEYS.FILTER_STATE, JSON.stringify(filterState));
    } catch (error) {
      console.error('保存筛选状态失败:', error);
    }
  }

  // 获取筛选状态
  public getFilterState(): FilterState {
    try {
      const data = localStorage.getItem(STORAGE_KEYS.FILTER_STATE);
      if (data) {
        return JSON.parse(data);
      }
    } catch (error) {
      console.error('获取筛选状态失败:', error);
    }
    
    // 返回默认状态
    return {
      searchKeyword: '',
      selectedGroupIds: [],
    };
  }

  // 添加活跃环境状态（智能互斥激活）
  public addActiveEnvironments(id: string, envType: EnvironmentType): void {
    const currentActive = this.getActiveEnvironments();
    
    if (envType === 'custom') {
      // 自定义环境：直接添加到活跃列表，不受互斥限制
      if (!currentActive.includes(id)) {
        currentActive.push(id);
      }
    } else {
      // 标准环境：清除其他标准环境，保留自定义环境
      // 由于我们无法在这里直接获取环境类型信息，需要调用方传入完整的环境信息
      // 这里先实现基础逻辑，后续可以通过重载方法优化
      
      // 清除所有环境，然后添加新的标准环境
      this.clearAllActiveEnvironments();
      currentActive.length = 0;
      currentActive.push(id);
      
      // 记录当前激活的标准环境类型
      localStorage.setItem(STORAGE_KEYS.ACTIVE_ENVIRONMENT_TYPE, envType);
    }
    
    try {
      localStorage.setItem(STORAGE_KEYS.ACTIVE_ENVIRONMENTS, JSON.stringify(currentActive));
    } catch (error) {
      console.error('保存活跃环境状态失败:', error);
    }
  }

  // 重载方法：添加活跃环境状态（传入完整环境信息）
  public addActiveEnvironmentsWithInfo(id: string, envType: EnvironmentType, allEnvironments: Array<{id: string, type: EnvironmentType}>): void {
    const currentActive = this.getActiveEnvironments();
    
    if (envType === 'custom') {
      // 自定义环境：直接添加到活跃列表，不受互斥限制
      if (!currentActive.includes(id)) {
        currentActive.push(id);
      }
    } else {
      // 标准环境：清除其他标准环境，保留自定义环境
      // 找出当前活跃的自定义环境
      const customEnvs = currentActive.filter(activeId => {
        const env = allEnvironments.find(e => e.id === activeId);
        return env && env.type === 'custom';
      });
      
      // 清除所有环境，然后添加新的标准环境 + 保留的自定义环境
      this.clearAllActiveEnvironments();
      currentActive.length = 0;
      
      // 先添加新的标准环境
      currentActive.push(id);
      
      // 再添加之前保留的自定义环境
      customEnvs.forEach(envId => {
        if (envId !== id) {
          currentActive.push(envId);
        }
      });
      
      // 记录当前激活的标准环境类型
      localStorage.setItem(STORAGE_KEYS.ACTIVE_ENVIRONMENT_TYPE, envType);
    }
    
    try {
      localStorage.setItem(STORAGE_KEYS.ACTIVE_ENVIRONMENTS, JSON.stringify(currentActive));
    } catch (error) {
      console.error('保存活跃环境状态失败:', error);
    }
  }
  
  // 删除活跃环境状态
  public deleteActiveEnvironments(id: string): void {
    const data = this.getActiveEnvironments();
    const index = data.indexOf(id);
    if (index > -1) {
      data.splice(index, 1);
      try {
        localStorage.setItem(STORAGE_KEYS.ACTIVE_ENVIRONMENTS, JSON.stringify(data));
        // 如果没有活跃环境，清除环境类型记录
        if (data.length === 0) {
          localStorage.removeItem(STORAGE_KEYS.ACTIVE_ENVIRONMENT_TYPE);
        }
      } catch (error) {
        console.error('删除活跃环境状态失败:', error);
      }
    }
  }

  // 获取活跃环境状态
  public getActiveEnvironments(): string[] {
    try {
      const data = localStorage.getItem(STORAGE_KEYS.ACTIVE_ENVIRONMENTS);
      if (data) {
        return JSON.parse(data);
      }
    } catch (error) {
      console.error('获取活跃环境状态失败:', error);
    }
    
    return [];
  }

  // 获取当前激活的环境类型
  public getActiveEnvironmentType(): EnvironmentType | null {
    try {
      const data = localStorage.getItem(STORAGE_KEYS.ACTIVE_ENVIRONMENT_TYPE);
      if (data) {
        return data as EnvironmentType;
      }
    } catch (error) {
      console.error('获取活跃环境类型失败:', error);
    }
    
    return null;
  }

  // 清除所有活跃环境
  public clearAllActiveEnvironments(): void {
    try {
      localStorage.removeItem(STORAGE_KEYS.ACTIVE_ENVIRONMENTS);
      localStorage.removeItem(STORAGE_KEYS.ACTIVE_ENVIRONMENT_TYPE);
    } catch (error) {
      console.error('清除活跃环境状态失败:', error);
    }
  }

  // 检查环境是否应该被激活（基于互斥逻辑）
  public shouldActivateEnvironment(envType: EnvironmentType): boolean {
    const currentActiveType = this.getActiveEnvironmentType();
    // 如果没有激活的环境，或者当前环境类型与要激活的类型不同，则可以激活
    return !currentActiveType || currentActiveType !== envType;
  }

  // 清除所有存储数据
  public clearAll(): void {
    try {
      localStorage.removeItem(STORAGE_KEYS.FILTER_STATE);
      localStorage.removeItem(STORAGE_KEYS.ACTIVE_ENVIRONMENTS);
      localStorage.removeItem(STORAGE_KEYS.ACTIVE_ENVIRONMENT_TYPE);
    } catch (error) {
      console.error('清除存储数据失败:', error);
    }
  }
}

// 导出单例实例
export const storageManager = StorageManager.getInstance();
